using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("AchieveManager")]
	public class AchieveManager : MonoClass
	{
		

		public static long TIMED_ACHIEVE_VALIDATION_DELAY_TICKS => MonoClass.smethod_6<long>(TritonHs.MainAssemblyPath, "", "AchieveManager", "TIMED_ACHIEVE_VALIDATION_DELAY_TICKS");

		public static long CHECK_LICENSE_ADDED_ACHIEVE_DELAY_TICKS => MonoClass.smethod_6<long>(TritonHs.MainAssemblyPath, "", "AchieveManager", "CHECK_LICENSE_ADDED_ACHIEVE_DELAY_TICKS");

		public static long TIMED_AND_LICENSE_ACHIEVE_CHECK_DELAY_TICKS => MonoClass.smethod_6<long>(TritonHs.MainAssemblyPath, "", "AchieveManager", "TIMED_AND_LICENSE_ACHIEVE_CHECK_DELAY_TICKS");

		public bool m_allNetAchievesReceived => method_2<bool>("m_allNetAchievesReceived");

		public int m_numEventResponsesNeeded => method_2<int>("m_numEventResponsesNeeded");

		public bool m_disableCancelButtonUntilServerReturns => method_2<bool>("m_disableCancelButtonUntilServerReturns");

		public long m_lastEventTimingAndLicenseAchieveCheck => method_2<long>("m_lastEventTimingAndLicenseAchieveCheck");

		public bool m_queueNotifications => method_2<bool>("m_queueNotifications");

		public List<int> m_achieveNotificationsToQueue => method_3<Class270<int>>("m_achieveNotificationsToQueue")?.method_25();

		public AchieveManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public AchieveManager(IntPtr address)
			: this(address, "AchieveManager")
		{
		}

		public static AchieveManager Get()
		{
			return MonoClass.smethod_15<AchieveManager>(TritonHs.MainAssemblyPath, "", "AchieveManager", "Get", Array.Empty<object>());
		}

		public static void Init()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "AchieveManager", "Init");
		}

		public static bool IsPredicateTrue(Achievement.Predicate predicate)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "AchieveManager", "IsPredicateTrue", new object[1] { predicate });
		}

		public static bool IsActiveQuest(Achievement obj, bool onlyNewlyActive)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "AchieveManager", "IsActiveQuest", new object[2] { obj, onlyNewlyActive });
		}

		public static bool IsAutoDestroyQuest(Achievement obj)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "AchieveManager", "IsAutoDestroyQuest", new object[1] { obj });
		}

		public static bool IsDialogQuest(Achievement obj)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "AchieveManager", "IsDialogQuest", new object[1] { obj });
		}

		public void InitAchieveManager()
		{
			method_8("InitAchieveManager");
		}

		public bool IsReady()
		{
			return method_11<bool>("IsReady", Array.Empty<object>());
		}

		public List<Achievement> GetNewCompletedAchievesToShow()
		{
			return method_14<Class271<Achievement>>("GetNewCompletedAchievesToShow", Array.Empty<object>())?.method_25();
		}

		public List<Achievement> GetActiveQuests(bool onlyNewlyActive)
		{
			return method_14<Class271<Achievement>>("GetActiveQuests", new object[1] { onlyNewlyActive })?.method_25();
		}

		public bool HasQuestsToShow(bool onlyNewlyActive)
		{
			return method_11<bool>("HasQuestsToShow", new object[1] { onlyNewlyActive });
		}

		public bool HasActiveQuests(bool onlyNewlyActive)
		{
			return method_11<bool>("HasActiveQuests", new object[1] { onlyNewlyActive });
		}

		public bool HasActiveAutoDestroyQuests()
		{
			return method_11<bool>("HasActiveAutoDestroyQuests", Array.Empty<object>());
		}

		public bool HasActiveUnseenWelcomeQuestDialog()
		{
			return method_11<bool>("HasActiveUnseenWelcomeQuestDialog", Array.Empty<object>());
		}

		public bool HasActiveDialogQuests()
		{
			return method_11<bool>("HasActiveDialogQuests", Array.Empty<object>());
		}

		public bool HasActiveQuestId(AchievementDbId id)
		{
			return method_11<bool>("HasActiveQuestId", new object[1] { id });
		}

		public List<Achievement> GetNewlyProgressedQuests()
		{
			return method_14<Class271<Achievement>>("GetNewlyProgressedQuests", Array.Empty<object>())?.method_25();
		}

		public bool HasUnlockedFeature(Achievement.UnlockableFeature feature)
		{
			return method_11<bool>("HasUnlockedFeature", new object[1] { feature });
		}

		public Achievement GetAchievement(int achieveID)
		{
			return method_14<Achievement>("GetAchievement", new object[1] { achieveID });
		}

		public int GetNumAchievesInGroup(Achievement.AchType achieveGroup)
		{
			return method_11<int>("GetNumAchievesInGroup", new object[1] { achieveGroup });
		}

		public List<Achievement> GetCompletedAchieves()
		{
			return method_14<Class271<Achievement>>("GetCompletedAchieves", Array.Empty<object>())?.method_25();
		}

		public List<Achievement> GetAchievesInGroup(Achievement.AchType achieveGroup)
		{
			return method_15<Class271<Achievement>>("GetAchievesInGroup", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { achieveGroup })?.method_25();
		}

		public List<Achievement> GetAchievesInGroup(Achievement.AchType achieveGroup, bool isComplete)
		{
			return method_15<Class271<Achievement>>("GetAchievesInGroup", new Class276.Enum20[2]
			{
				Class276.Enum20.ValueType,
				Class276.Enum20.Boolean
			}, new object[2] { achieveGroup, isComplete })?.method_25();
		}

		public List<Achievement> GetAchievesForAdventureWing(int wingID)
		{
			return method_14<Class271<Achievement>>("GetAchievesForAdventureWing", new object[1] { wingID })?.method_25();
		}

		public Achievement GetUnlockGoldenHeroAchievement(string heroCardID, TAG_PREMIUM premium)
		{
			return method_14<Achievement>("GetUnlockGoldenHeroAchievement", new object[2] { heroCardID, premium });
		}

		public bool HasActiveAchievesForEvent(SpecialEventType eventTrigger)
		{
			return method_11<bool>("HasActiveAchievesForEvent", new object[1] { eventTrigger });
		}

		public bool CanCancelQuest(int achieveID)
		{
			return method_11<bool>("CanCancelQuest", new object[1] { achieveID });
		}

		public void CancelQuest(int achieveID)
		{
			method_8("CancelQuest", achieveID);
		}

		public bool HasActiveLicenseAddedAchieves()
		{
			return method_11<bool>("HasActiveLicenseAddedAchieves", Array.Empty<object>());
		}

		public bool HasIncompletePurchaseAchieves()
		{
			return method_11<bool>("HasIncompletePurchaseAchieves", Array.Empty<object>());
		}

		public bool HasIncompleteDisenchantAchieves()
		{
			return method_11<bool>("HasIncompleteDisenchantAchieves", Array.Empty<object>());
		}

		public void NotifyOfClick(Achievement.ClickTriggerType clickType)
		{
			method_8("NotifyOfClick", clickType);
		}

		public void CompleteAutoDestroyAchieve(int achieveId)
		{
			method_8("CompleteAutoDestroyAchieve", achieveId);
		}

		public void NotifyOfAccountCreation()
		{
			method_8("NotifyOfAccountCreation");
		}

		public void NotifyOfCardGained(EntityDef entityDef, TAG_PREMIUM premium, int totalCount)
		{
			method_8("NotifyOfCardGained", entityDef, premium, totalCount);
		}

		public void NotifyOfPacksReadyToOpen(UnopenedPack unopenedPack)
		{
			method_8("NotifyOfPacksReadyToOpen", unopenedPack);
		}

		public void Heartbeat()
		{
			method_8("Heartbeat");
		}

		public void ValidateAchievesNow()
		{
			method_8("ValidateAchievesNow");
		}

		public void CheckPlayedNearbyPlayerOnSubnet()
		{
			method_8("CheckPlayedNearbyPlayerOnSubnet");
		}

		public void LoadAchievesFromDBF()
		{
			method_8("LoadAchievesFromDBF");
		}

		public void InitAchievement(Achievement achievement)
		{
			method_8("InitAchievement", achievement);
		}

		public void WillReset()
		{
			method_8("WillReset");
		}

		public void BlockNotification(int achieveIdToQueue)
		{
			method_8("BlockNotification", achieveIdToQueue);
		}

		public void UnblockNotification(int achieveIdToUnblock)
		{
			method_8("UnblockNotification", achieveIdToUnblock);
		}

		public void BlockAllNotifications()
		{
			method_8("BlockAllNotifications");
		}

		public void UnblockAllNotifications()
		{
			method_8("UnblockAllNotifications");
		}

		public void OnQuestCanceled()
		{
			method_8("OnQuestCanceled");
		}

		public void OnAchieveValidated()
		{
			method_8("OnAchieveValidated");
		}

		public void OnEventTriggered()
		{
			method_8("OnEventTriggered");
		}

		public void OnAccountLicenseAchieveResponse()
		{
			method_8("OnAccountLicenseAchieveResponse");
		}

		public void OnAccountLicenseAchievesUpdated(object userData)
		{
			method_8("OnAccountLicenseAchievesUpdated", userData);
		}

		public void FireLicenseAddedAchievesUpdatedEvent()
		{
			method_8("FireLicenseAddedAchievesUpdatedEvent");
		}

		public bool CanCancelQuestNow()
		{
			return method_11<bool>("CanCancelQuestNow", Array.Empty<object>());
		}

		public void FireAchieveCanceledEvent(int achieveID, bool success)
		{
			method_8("FireAchieveCanceledEvent", achieveID, success);
		}

		public void CheckAllCardGainAchieves()
		{
			method_8("CheckAllCardGainAchieves");
		}

		public void CheckTimedEventsAndLicenses(DateTime utcNow)
		{
			method_8("CheckTimedEventsAndLicenses", utcNow);
		}

		public List<Achievement> GetActiveLicenseAddedAchieves()
		{
			return method_14<Class271<Achievement>>("GetActiveLicenseAddedAchieves", Array.Empty<object>())?.method_25();
		}
	}
}
